AsymmetricAlgorithm.KeySize Propiedad

Definición

Espacio de nombres:

System.Security.Cryptography

Ensamblado:

System.Security.Cryptography.dll

Source:

AsymmetricAlgorithm.cs

Obtiene o establece el tamaño, en bits, del módulo de claves que usa el algoritmo asimétrico.

public:
 virtual property int KeySize { int get(); void set(int value); };

public virtual int KeySize { get; set; }

member this.KeySize : int with get, set

Public Overridable Property KeySize As Integer

Valor de propiedad

Int32

Tamaño, en bits, del módulo de claves que usa el algoritmo asimétrico.

Excepciones

CryptographicException

El tamaño del módulo de claves no es válido.

Ejemplos

En el ejemplo de código siguiente se muestra cómo invalidar la KeySize propiedad para comprobar que se encuentra dentro del intervalo identificado en la variable miembro local keySizes . Este ejemplo de código es parte de un ejemplo más grande proporcionado para la clase AsymmetricAlgorithm.

public:
    property int KeySize
    {
        virtual int get() override
        {
            return KeySizeValue;
        }

        virtual void set(int value) override
        {
            for (int i = 0; i < customValidKeySizes->Length; i++)
            {
                if (customValidKeySizes[i]->SkipSize == 0)
                {
                    if (customValidKeySizes[i]->MinSize == value)
                    {
                        KeySizeValue = value;
                        return;
                    }
                }
                else
                {
                    for (int j = customValidKeySizes[i]->MinSize;
                        j <= customValidKeySizes[i]->MaxSize;
                        j += customValidKeySizes[i]->SkipSize)
                    {
                        if (j == value)
                        {
                            KeySizeValue = value;
                            return;
                        }
                    }
                }
            }

            // If the key does not fall within the range identified
            // in the keySizes member variable, throw an exception.
            throw gcnew CryptographicException("Invalid key size.");
        }
    }

public override int KeySize 
{
    get { return KeySizeValue; }
    set
    {
        for (int i=0; i < keySizes.Length; i++)
        {
            if (keySizes[i].SkipSize == 0) 
            {
                if (keySizes[i].MinSize == value)
                {
                    KeySizeValue = value;
                    return;
                }
            }
            else
            {
                for (int j = keySizes[i].MinSize;
                    j <= keySizes[i].MaxSize;
                    j += keySizes[i].SkipSize)
                {
                    if (j == value)
                    {
                        KeySizeValue = value;
                        return;
                    }
                }
            }
        }

        // If the key does not fall within the range identified 
        // in the keySizes member variable, throw an exception.
        throw new CryptographicException("Invalid key size.");
    }
}

Public Overrides Property KeySize() As Integer
    Get
        Return KeySizeValue
    End Get
    Set(ByVal Value As Integer)
        For i As Int16 = 0 To keySizes.Length - 1 Step i
            If (keySizes(i).SkipSize.Equals(0)) Then
                If (keySizes(i).MinSize.Equals(Value)) Then
                    KeySizeValue = Value
                    Return
                End If
            Else
                For j As Integer = keySizes(i).MinSize _
                    To keySizes(i).MaxSize _
                    Step keySizes(i).SkipSize
                    If (j.Equals(Value)) Then
                        KeySizeValue = Value
                        Return
                    End If
                Next
            End If
        Next
        ' If the key does not fall within the range identified 
        ' in the keySizes member variable, throw an exception.
        Throw New CryptographicException("Invalid key size.")
    End Set
End Property

Comentarios

Los tamaños de clave válidos se especifican mediante la implementación concreta del algoritmo asimétrico y se enumeran en la LegalKeySizes propiedad .

Consulte también

• servicios criptográficos