implémentation .NET (bibliothèques) de cryptographie de courbe elliptique

Question

S'il vous plaît pouvez-vous suggérer une mise en œuvre de la cryptographie à courbes elliptiques à utiliser sur la plate-forme .NET?

Aussi, si vous les avez utilisés, pouvez-vous me dire les courbes recommandées qui devraient être utilisées?

[EDIT]

Comme mentionné @FatCat, sa mise en œuvre est disponible dans .NET Framework 3.5, mais qui est disponible uniquement sur windows vista. Pouvez-vous s'il vous plaît suggérer une autre façon / bibliothèque pour l'utiliser?

Answer 1

Consultez la bibliothèque Bouncy Castle C #, il a ECDH et ECDSA.

Answer 2

Le cadre .NET comprend déjà Diffie-Hellman, qui est un algorithme de chiffrement à courbe elliptique. Regardez sous System.Security.Cryptography.ECDiffieHellmanCng .

Answer 3

Jetez un oeil à composants de SecureBlackbox

Answer 4

La façon dont vous utilisez habituellement ECC pour le chiffrement est en utilisant "Diffie-Hellman statique éphémère".

Il fonctionne de cette façon:

• Prendre les récepteurs destinés à clé publique (peut-être d'un certificat). Ceci est la clé statique.
• Générer un ECDH temporaire keypair. Ceci est l'éphémère keypair.
• Utilisez les touches pour générer une clé symétrique partagée.
• Chiffrer les données avec la clé symétrique.
• Transmettre les données chiffrées avec la clé publique de l'éphémère keypair.

Le récepteur peut maintenant utiliser la clé publique éphémère et sa propre clé privée statique pour recréer la clé symétrique et décrypter les données.

Vous pouvez en savoir plus Normes pour Cryptography efficace: SEC 1: Curve Cryptography Elliptic section 5.1.3.

Answer 5

  

Great! Je l'ai essayé, mais ne peux pas trouver comment l'utiliser pour chiffrer un message.   Ne semble pas avoir une fonction « Encrypt »

l'exemple MSDN System.Security.Cryptography.ECDiffieHellmanCng .

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


class Alice
{
    public static byte[] alicePublicKey;

    public static void Main(string[] args)
    {
        using (ECDiffieHellmanCng alice = new ECDiffieHellmanCng())
        {

            alice.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
            alice.HashAlgorithm = CngAlgorithm.Sha256;
            alicePublicKey = alice.PublicKey.ToByteArray();
            Bob bob = new Bob();
            CngKey k = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob);
            byte[] aliceKey = alice.DeriveKeyMaterial(CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob));
            byte[] encryptedMessage = null;
            byte[] iv = null;
            Send(aliceKey, "Secret message", out encryptedMessage, out iv);
            bob.Receive(encryptedMessage, iv);
        }

    }

    private static void Send(byte[] key, string secretMessage, out byte[] encryptedMessage, out byte[] iv)
    {
        using (Aes aes = new AesCryptoServiceProvider())
        {
            aes.Key = key;
            iv = aes.IV;

            // Encrypt the message 
            using (MemoryStream ciphertext = new MemoryStream())
            using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write))
            {
                byte[] plaintextMessage = Encoding.UTF8.GetBytes(secretMessage);
                cs.Write(plaintextMessage, 0, plaintextMessage.Length);
                cs.Close();
                encryptedMessage = ciphertext.ToArray();
            }
        }
    }

}
public class Bob 
{
    public byte[] bobPublicKey;
    private byte[] bobKey;
    public Bob()
    {
        using (ECDiffieHellmanCng bob = new ECDiffieHellmanCng())
        {

            bob.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
            bob.HashAlgorithm = CngAlgorithm.Sha256;
            bobPublicKey = bob.PublicKey.ToByteArray();
            bobKey = bob.DeriveKeyMaterial(CngKey.Import(Alice.alicePublicKey, CngKeyBlobFormat.EccPublicBlob));

        }
    }

    public void Receive(byte[] encryptedMessage, byte[] iv)
    {

        using (Aes aes = new AesCryptoServiceProvider())
        {
            aes.Key = bobKey;
            aes.IV = iv;
            // Decrypt the message 
            using (MemoryStream plaintext = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(encryptedMessage, 0, encryptedMessage.Length);
                    cs.Close();
                    string message = Encoding.UTF8.GetString(plaintext.ToArray());
                    Console.WriteLine(message);
                }
            }
        }
    }

}