PasswordDeriveBytes Clase

Referencia

Definición

Espacio de nombres:: System.Security.Cryptography

Ensamblado:: System.Security.Cryptography.Csp.dll

Ensamblado:: System.Security.Cryptography.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Deriva una clave de una contraseña mediante una extensión del algoritmo PBKDF1.

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

public class PasswordDeriveBytes : System.Security.Cryptography.DeriveBytes

[System.Runtime.InteropServices.ComVisible(true)]
public class PasswordDeriveBytes : System.Security.Cryptography.DeriveBytes

type PasswordDeriveBytes = class
    inherit DeriveBytes

[<System.Runtime.InteropServices.ComVisible(true)>]
type PasswordDeriveBytes = class
    inherit DeriveBytes

Public Class PasswordDeriveBytes
Inherits DeriveBytes

Herencia: Object

DeriveBytes
PasswordDeriveBytes

Atributos: ComVisibleAttribute

Ejemplos

En el ejemplo de código siguiente se crea una clave a partir de una contraseña mediante la PasswordDeriveBytes clase .

using namespace System;
using namespace System::Security::Cryptography;
using namespace System::Text;

// Generates a random salt value of the specified length.
array<Byte>^ CreateRandomSalt(int length)
{
    // Create a buffer
    array<Byte>^ randomBytes;

    if (length >= 1)
    {
        randomBytes = gcnew array <Byte>(length);
    }
    else
    {
        randomBytes = gcnew array <Byte>(1);
    }

    // Create a new RNGCryptoServiceProvider.
    RNGCryptoServiceProvider^ cryptoRNGProvider =
        gcnew RNGCryptoServiceProvider();

    // Fill the buffer with random bytes.
    cryptoRNGProvider->GetBytes(randomBytes);

    // return the bytes.
    return randomBytes;
}

// Clears the bytes in a buffer so they can't later be read from memory.
void ClearBytes(array<Byte>^ buffer)
{
    // Check arguments.
    if (buffer == nullptr)
    {
        throw gcnew ArgumentNullException("buffer");
    }

    // Set each byte in the buffer to 0.
    for (int x = 0; x <= buffer->Length - 1; x++)
    {
        buffer[x] = 0;
    }
}

int main(array<String^>^ args)
{

    // Get a password from the user.
    Console::WriteLine("Enter a password to produce a key:");

    // Security Note: Never hard-code a password within your
    // source code.  Hard-coded passwords can be retrieved
    // from a compiled assembly.
    array<Byte>^ password = Encoding::Unicode->GetBytes(Console::ReadLine());

    array<Byte>^ randomSalt = CreateRandomSalt(7);

    // Create a TripleDESCryptoServiceProvider object.
    TripleDESCryptoServiceProvider^ cryptoDESProvider =
        gcnew TripleDESCryptoServiceProvider();

    try
    {
        Console::WriteLine("Creating a key with PasswordDeriveBytes...");

        // Create a PasswordDeriveBytes object and then create
        // a TripleDES key from the password and salt.
        PasswordDeriveBytes^ passwordDeriveBytes = gcnew PasswordDeriveBytes
            (password->ToString(), randomSalt);

       // Create the key and set it to the Key property
       // of the TripleDESCryptoServiceProvider object.
       // This example uses the SHA1 algorithm.
       // Due to collision problems with SHA1, Microsoft recommends SHA256 or better.
        cryptoDESProvider->Key = passwordDeriveBytes->CryptDeriveKey
            ("TripleDES", "SHA1", 192, cryptoDESProvider->IV);
        Console::WriteLine("Operation complete.");
    }
    catch (Exception^ ex)
    {
        Console::WriteLine(ex->Message);
    }
    finally
    {
        // Clear the buffers
        ClearBytes(password);
        ClearBytes(randomSalt);

        // Clear the key.
        cryptoDESProvider->Clear();
    }

    Console::ReadLine();
}

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

public class PasswordDerivedBytesExample
{

    public static void Main(String[] args)
    {

        // Get a password from the user.
        Console.WriteLine("Enter a password to produce a key:");

        byte[] pwd = Encoding.Unicode.GetBytes(Console.ReadLine());

        byte[] salt = CreateRandomSalt(7);

        // Create a TripleDESCryptoServiceProvider object.
        TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();

        try
        {
            Console.WriteLine("Creating a key with PasswordDeriveBytes...");

            // Create a PasswordDeriveBytes object and then create
            // a TripleDES key from the password and salt.
            PasswordDeriveBytes pdb = new PasswordDeriveBytes(pwd, salt);


            // Create the key and set it to the Key property
            // of the TripleDESCryptoServiceProvider object.
            // This example uses the SHA1 algorithm.
            // Due to collision problems with SHA1, Microsoft recommends SHA256 or better.
            tdes.Key = pdb.CryptDeriveKey("TripleDES", "SHA1", 192, tdes.IV);


            Console.WriteLine("Operation complete.");
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            // Clear the buffers
            ClearBytes(pwd);
            ClearBytes(salt);

            // Clear the key.
            tdes.Clear();
        }

        Console.ReadLine();
    }

    //////////////////////////////////////////////////////////
    // Helper methods:
    // CreateRandomSalt: Generates a random salt value of the
    //                   specified length.
    //
    // ClearBytes: Clear the bytes in a buffer so they can't
    //             later be read from memory.
    //////////////////////////////////////////////////////////

    public static byte[] CreateRandomSalt(int length)
    {
        // Create a buffer
        byte[] randBytes;

        if (length >= 1)
        {
            randBytes = new byte[length];
        }
        else
        {
            randBytes = new byte[1];
        }

        // Create a new RNGCryptoServiceProvider.
        RNGCryptoServiceProvider rand = new RNGCryptoServiceProvider();

        // Fill the buffer with random bytes.
        rand.GetBytes(randBytes);

        // return the bytes.
        return randBytes;
    }

    public static void ClearBytes(byte[] buffer)
    {
        // Check arguments.
        if (buffer == null)
        {
            throw new ArgumentException("buffer");
        }

        // Set each byte in the buffer to 0.
        for (int x = 0; x < buffer.Length; x++)
        {
            buffer[x] = 0;
        }
    }
}

Imports System.Security.Cryptography
Imports System.Text



Module PasswordDerivedBytesExample


    Sub Main(ByVal args() As String)

        ' Get a password from the user.
        Console.WriteLine("Enter a password to produce a key:")

        Dim pwd As Byte() = Encoding.Unicode.GetBytes(Console.ReadLine())

        Dim salt As Byte() = CreateRandomSalt(7)

        ' Create a TripleDESCryptoServiceProvider object.
        Dim tdes As New TripleDESCryptoServiceProvider()

        Try
            Console.WriteLine("Creating a key with PasswordDeriveBytes...")

            ' Create a PasswordDeriveBytes object and then create 
            ' a TripleDES key from the password and salt.
            Dim pdb As New PasswordDeriveBytes(pwd, salt)


            ' Create the key and set it to the Key property
            ' of the TripleDESCryptoServiceProvider object.
            ' This example uses the SHA1 algorithm.
            ' Due to collision problems with SHA1, Microsoft recommends SHA256 or better.
            tdes.Key = pdb.CryptDeriveKey("TripleDES", "SHA1", 192, tdes.IV)


            Console.WriteLine("Operation complete.")
        Catch e As Exception
            Console.WriteLine(e.Message)
        Finally
            ' Clear the buffers
            ClearBytes(pwd)
            ClearBytes(salt)

            ' Clear the key.
            tdes.Clear()
        End Try

        Console.ReadLine()

    End Sub


    '********************************************************
    '* Helper methods:
    '* createRandomSalt: Generates a random salt value of the 
    '*                   specified length.  
    '*
    '* clearBytes: Clear the bytes in a buffer so they can't 
    '*             later be read from memory.
    '********************************************************
    Function CreateRandomSalt(ByVal length As Integer) As Byte()
        ' Create a buffer
        Dim randBytes() As Byte

        If length >= 1 Then
            randBytes = New Byte(length) {}
        Else
            randBytes = New Byte(0) {}
        End If

        ' Create a new RNGCryptoServiceProvider.
        Dim rand As New RNGCryptoServiceProvider()

        ' Fill the buffer with random bytes.
        rand.GetBytes(randBytes)

        ' return the bytes.
        Return randBytes

    End Function


    Sub ClearBytes(ByVal buffer() As Byte)
        ' Check arguments.
        If buffer Is Nothing Then
            Throw New ArgumentException("buffer")
        End If

        ' Set each byte in the buffer to 0.
        Dim x As Integer
        For x = 0 To buffer.Length - 1
            buffer(x) = 0
        Next x

    End Sub
End Module

Comentarios

Esta clase usa una extensión del algoritmo PBKDF1 definido en el estándar PKCS#5 v2.0 para derivar bytes adecuados para su uso como material clave de una contraseña. El estándar se documenta en IETF RRC 2898.

Importante

Nunca codifique de forma rígida una contraseña en el código fuente. Las contraseñas codificadas de forma rígida se pueden recuperar de un ensamblado mediante la herramienta Ildasm.exe (desensamblador de IL), un editor hexadecimal o simplemente abriendo el ensamblado en un editor de texto como notepad.exe.

Constructores

PasswordDeriveBytes(Byte[], Byte[])	Inicializa una nueva instancia de la clase PasswordDeriveBytes especificando la contraseña y el valor de clave "salt" que se van a usar para derivar la clave.
PasswordDeriveBytes(Byte[], Byte[], CspParameters)	Inicializa una nueva instancia de la clase PasswordDeriveBytes especificando la contraseña, el valor de clave "salt" y los parámetros del proveedor de servicios criptográficos (CSP) que se van a usar para derivar la clave.
PasswordDeriveBytes(Byte[], Byte[], String, Int32)	Inicializa una nueva instancia de la clase PasswordDeriveBytes especificando la contraseña, el valor de clave "salt", el nombre hash y las iteraciones que se van a usar para derivar la clave.
PasswordDeriveBytes(Byte[], Byte[], String, Int32, CspParameters)	Inicializa una nueva instancia de la clase PasswordDeriveBytes especificando la contraseña, el valor de clave "salt", el nombre del algoritmo hash, las iteraciones y los parámetros del proveedor de servicios criptográficos (CSP) que se van a usar para derivar la clave.
PasswordDeriveBytes(String, Byte[])	Inicializa una nueva instancia de la clase PasswordDeriveBytes con la contraseña y el valor de clave "salt" de clave que se van a usar para derivar la clave.
PasswordDeriveBytes(String, Byte[], CspParameters)	Inicializa una nueva instancia de la clase PasswordDeriveBytes con la contraseña, el valor de clave "salt" y los parámetros del proveedor de servicios criptográficos (CSP) que se van a usar para derivar la clave.
PasswordDeriveBytes(String, Byte[], String, Int32)	Inicializa una nueva instancia de la clase PasswordDeriveBytes con la contraseña, el valor de clave "salt", el nombre hash y el número de iteraciones que se van a usar para derivar la clave.
PasswordDeriveBytes(String, Byte[], String, Int32, CspParameters)	Inicializa una nueva instancia de la clase PasswordDeriveBytes con la contraseña, el valor de clave "salt", el nombre hash, el número de iteraciones y los parámetros del proveedor de servicios criptográficos (CSP) que se van a usar para derivar la clave.

Propiedades

HashName	Obtiene o establece el nombre del algoritmo hash de la operación.
IterationCount	Obtiene o establece el número de iteraciones de la operación.
Salt	Obtiene o establece el valor de clave "salt" de la operación.

Métodos

CryptDeriveKey(String, String, Int32, Byte[])	Deriva una clave criptográfica a partir del objeto PasswordDeriveBytes.
Dispose()	Cuando se reemplaza en una clase derivada, libera todos los recursos usados por la instancia actual de la clase DeriveBytes. (Heredado de DeriveBytes)
Dispose(Boolean)	Libera los recursos no administrados utilizados por la clase PasswordDeriveBytes y, de forma opcional, libera los recursos administrados.
Dispose(Boolean)	Cuando se reemplaza en una clase derivada, libera los recursos no administrados usados por la clase DeriveBytes y, de forma opcional, libera los recursos administrados. (Heredado de DeriveBytes)
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
Finalize()	Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de que sea reclamado por la recolección de elementos no utilizados.
GetBytes(Int32)	Obsoleto. Devuelve bytes de clave pseudoaleatorios.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
Reset()	Restablece el estado de la operación.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Se aplica a

Consulte también

servicios criptográficos