Implementacja .NET (biblioteki) kryptografii krzywej eliptycznej

Question

Czy możesz zaproponować implementację kryptografii krzywych eliptycznych do użycia na platformie .NET?

Również jeśli użyłeś ich, czy możesz powiedzieć mi zalecane krzywe, które powinny być używane?

[EDIT]

Jak wspomniano @FatCat, jego realizacja jest dostępne w .NET Framework 3.5, ale jest dostępny tylko w systemie Windows Vista. Czy możesz zaproponować inny sposób/bibliotekę, aby go użyć?

Answer 1

Sprawdź bibliotekę Bouncy Castle dla języka C#, która ma ECDH i ECDSA.

Answer 2

System .NET Framework zawiera już Diffiego-Hellmana, który jest algorytmem kryptograficznym z krzywą eliptyczną. Zajrzyj pod System.Security.Cryptography.ECDiffieHellmanCng.

Answer 3

Sposób, w jaki zwykle używa się ECC do szyfrowania, to "Efemeryczna-statyczna Diffie-Hellman".

To działa w ten sposób:

• Połykają przeznaczone odbiorniki klucza publicznego (być może z certyfikatem). To jest klucz statyczny.
• Generowanie tymczasowej pary kluczy ECDH. To jest efemeryczny klucz.
• Użyj klawiszy do wygenerowania wspólnego klucza symetrycznego.
• Szyfruj dane za pomocą klucza symetrycznego.
• Przesyłaj zaszyfrowane dane razem z kluczem publicznym z efemerycznej pary kluczy.

Odbiornik może teraz używać efemerycznego klucza publicznego i własnego statycznego klucza prywatnego do odtworzenia klucza symetrycznego i odszyfrowania danych.

Możesz przeczytać więcej w sekcji 01.sekcja 5.1.3.

Answer 4

Wystarczy popatrzeć na SecureBlackBox komponentów

Answer 5

Great! Próbowałem, ale nie mogę znaleźć, jak go użyć do zaszyfrowania wiadomości. wydaje się nie mieć żadnej funkcji

Ta próbka MSDN dla System.Security.Cryptography.ECDiffieHellmanCng „szyfrowania”.

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); 
       } 
      } 
     } 
    } 

}