AsymmetricAlgorithm.KeySize Propriété

Définition

Espace de noms:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Source:

AsymmetricAlgorithm.cs

Obtient ou définit la taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique.

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

Valeur de propriété

Int32

Taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique.

Exceptions

CryptographicException

La taille du modulo de la clé n’est pas valide.

Exemples

L’exemple de code suivant montre comment remplacer la KeySize propriété pour vérifier qu’elle se situe dans la plage identifiée dans la variable membre locale keySizes . Cet exemple de code fait partie d’un exemple plus grand fourni pour la AsymmetricAlgorithm classe .

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

Remarques

Les tailles de clé valides sont spécifiées par l’implémentation particulière de l’algorithme asymétrique et sont répertoriées dans la LegalKeySizes propriété .

Voir aussi

• services de chiffrement