Elliptikus görbék

A RSA az Diffie-Hellmann algoritmus esetén a biztonság eléréséhez igen nagy méretű egész számokra van szükség, hogy biztonságos kommunikációs rendszert kapjunk. Ez azért problémás, mivel a számítógépek számítási teljesítménye folyamatosan növekszik és egyre nagyobb méretű kulcsokat kell használnunk. Például a 2000-es évek elején még egy 1024 bites RSA kulcs biztonságosnak volt tekinthető, de a 2000-es évek közepén már 2048 bit volt javasolt, manapság pedig inkább 4096 bit alkalmazott.

Éppen ezért kerültek elÅ‘térbe kriptográfiában az elliptikus görbék. Az elliptikus görbe egy sima (differenciálható) harmadfokú görbe a projektív síkban, aminek a nemszáma¹ 1. Egy ilyen görbe általános egyenlete y² = x³ + ax + b formában írható fel. Az elliptikus görbe elnevezés onnan származik, hogy elliptikus integrálokat paramétereznek.

Kriptográfiai jelentőségük abban a nehézségben rejlik, hogy lehetetlen kiszámítani egy véletlenszerű elliptikus görbe elem diszkrét logaritmusát egy nyilvánosan ismert alapponthoz viszonyítva.

Az RSA-hoz képest egyenértékű kriptográfiai erősséget kínálnak jóval alacsonyabb kulcsmérettel. Az alábbi táblázat a különböző rendszerek egyenértékű kulcsméretét foglalja össze bitben kifejezve:

A kisebb kulcsméret azt is jelenti, hogy erősebb titkosítás érhető el kevesebb számítási teljesítmény és hálózati sávszélesség mellett, ami ideális jelöltté teszi az elliptikus módszereket IoT környezetekben is.

Diffie-Helmann

A Diffie-Helmann kulcscsere is adaptálható elliptikus görbékre. Ezt nevezzük ECDiffieHellman algoritmusnak. .NET esetén a Diffie-Helmann kulcscserének csak ezen változata implementált. Az alábbi példakód ennek a használatát mutatja be:

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 bobKey = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob);
            byte[] aliceKey = alice.DeriveKeyMaterial(bobKey);
            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);
                }
            }
        }
    }
}