Elliptic Curve Cryptography (ECC)

In this tutorial you will learn the elliptic curve cryptography algorithm it’s various encryption algorithms, digital signature algorithm, key agreement algorithms, advantages of Elliptic Curve Cryptography, and a comparison between ECC and RSA algorithm.

• Elliptic Curve Cryptography (ECC) is a public-key cryptographic algorithm based on the algebraic structure of elliptic curves over finite fields.
• It is widely used in securing sensitive data in various applications using encryption and decryption techniques.
• ECC is also used for digital signature to verify the authenticity of a data.

Encryption algorithm in ECC

Below are the encryption algorithms used in Elliptic Curve Cryptography (ECC).

ECIES (Elliptic Curve Integrated Encryption Scheme)

• ECIES is an encryption scheme in ECC that combines symmetric encryption with ECC for secure data transmission.
• ECIES uses ECC for key agreement to establish a shared secret key which is then used for symmetric encryption of the actual data.
• ECIES provides a good balance between security and efficiency, making it suitable for various cryptographic applications.

EEECC (EC-based ElGamal)

• EEECC algorithm is a variant of the ElGamal encryption scheme that uses ECC for key exchange and encryption.
• It employs ECC operations like point multiplication and addition to generate shared secrets and encrypt data securely.
• EEECC is commonly used in scenarios where ECC-based encryption and key exchange are desired.

EC ElGamal Encryption

• This is a simplified version of ElGamal encryption specifically tailored for elliptic curves.
• It involves selecting a random scalar k, computing 𝑘×𝐺 to generate an ephemeral key pair, and then using this key pair for encryption.
• EC ElGamal encryption provides confidentiality and is often used in ECC-based cryptographic protocols.

Encryption algorithm in ECC using java.

The following Java source code demonstrates the use of the ECC encryption algorithm for encrypting and decrypting data.

package asymmetricCryptography;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.ECGenParameterSpec;
import java.util.Scanner;

public class EccExample {
    public static void main(String[] args) throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        // STEP 1: Ask for user input from keyboard
        Scanner in = new Scanner(System.in);
        System.out.println("Enter a message to encrypt using ECC:");
        String userMessage = in.nextLine();

        // STEP 2: Generate an ECC keypair
        KeyPair keypair = generateKeyPair();
        PrivateKey privateKey = keypair.getPrivate();
        PublicKey publicKey = keypair.getPublic();

        // Step 3: Encryption on our message

        byte [] cipherText = encrypt(userMessage, publicKey);
        System.out.println("Original message is: " + userMessage);
        System.out.println("Encrypted message using EC is " + new String(cipherText));

        // Step 4: Decryption
        String originalText = decrypt(cipherText, privateKey);

        System.out.println("The decoded information using private key is " + originalText);
    }

    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC");
        ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256k1");
        keyPairGenerator.initialize(ecSpec);
        return keyPairGenerator.generateKeyPair();
    }

    public static byte[] encrypt(String message, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("ECIES", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(message.getBytes());

    }

    public static String decrypt(byte [] cipherText, PrivateKey privateKey) throws  Exception {
        Cipher cipher = Cipher.getInstance("ECIES", "BC");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return new String(cipher.doFinal(cipherText));
    }
}

Digital signature algorithm in ECC

Digital signatures are employed to verify the authenticity, integrity, and non-repudiation of information. Two widely used digital signature algorithms in elliptic curve cryptography include ECDSA and EdDSA algorithm.

• Elliptic Curve Digital Signature Algorithm (ECDSA)
• Edwards-curve Digital Signature Algorithm (EdDSA).

Elliptic Curve Digital Signature Algorithm (ECDSA)

ECDSA is a sophisticated public-key cryptography encryption algorithm. It leverages the algebraic properties of elliptic curves within finite fields.

Edwards-curve Digital Signature Algorithm (EdDSA)

• EdDSA serves as an alternative to ECDSA, designed to provide fast public-key digital signatures with improved performance and simplified implementations. Its use of Edwards curves contributes to its efficiency and security, particularly in embedded devices where resource constraints are a concern.
• EdDSA’s design reduces the vulnerability to certain side-channel attacks, enhancing its overall security posture.

ECC digital signature implementation in java

This Java code below demonstrates the process of generating an ECDSA digital signature on a user defined message using private key and verifying the signature’s authenticity using public key.

import java.security.*;
import java.security.spec.ECGenParameterSpec;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.util.Base64;

public class ECDSASignatureExample {
    public static void main(String[] args) throws Exception {
        // Generate ECDSA key pair
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC");
        
        // Defin Elliptic curve parameters
        ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256r1"); 
        keyGen.initialize(ecSpec);
        KeyPair keyPair = keyGen.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();

        // Create a digital signature for an input message annd sign 
        Signature signature = Signature.getInstance("SHA256withECDSA");
        signature.initSign(privateKey);
        String data = "Hello, world!";
        signature.update(data.getBytes());
        byte[] digitalSignature = signature.sign();

        // Verify the digital signature using public key
        signature.initVerify(publicKey);
        signature.update(data.getBytes());
        boolean isVerified = signature.verify(digitalSignature);

        // Print results
        System.out.println("Original data: " + data);
        System.out.println("Digital Signature: " + Base64.getEncoder().encodeToString(digitalSignature));
        System.out.println("Is Signature Verified: " + isVerified);
    }
}

Key Agreement algorithm in ECC

Elliptic-curve Diffie-Hellman (ECDH)

• ECDH is a key agreement protocol used to establish a shared secret between two parties over an insecure communication channel.
• Each party possesses an elliptic-curve public-private key pair.
• The protocol involves the following steps:
• Both parties exchange their public keys.
• They each compute a shared secret using their private key and the received public key.
• This shared secret can be used directly as a key or used to derive another key for encryption purposes.
• ECDH provides forward secrecy and is widely used in secure communication protocols.

Fully Hashed Menezes-Qu-Vanstone (FHMQV)

• FHMQV is an authenticated key agreement protocol based on the Diffie-Hellman scheme.
• It is an extension of the MQV scheme and offers protection against active attackers.
• The protocol can be adapted to work in any finite group, including elliptic curve groups, where it is known as elliptic curve MQV (ECMQV).
• ECMQV enhances security by using additional hashing and authentication mechanisms.
• It enables parties to establish a shared secret securely, ensuring the confidentiality and integrity of communications.

Elliptic curve cryptography algorithm implementation in java

Advantage of Elliptic Curve Cryptography (ECC)

Elliptic Curve Cryptography (ECC) offers numerous benefits over traditional cryptographic systems, making it a popular choice for protecting sensitive data and communications across different applications. The advantages of ECC include:

Strong Security with Smaller Key Sizes

• Elliptic Curve Cryptography (ECC) provides an equivalent or even stronger security compared to other cryptographic algorithms like RSA but with smaller key sizes.
• The advantage of using smaller key size is crucial for resource-constrained environments like mobile devices and IoT devices, where storage and computational power are limited.

Resistance to Quantum Attacks

• Elliptic Curve Cryptography (ECC) is inherently resistant to quantum attacks due to the complexity of solving the Elliptic Curve Discrete Logarithm Problem (ECDLP) on elliptic curves.
• Quantum computers can break regular cryptographic systems, but when it comes to ECC, they struggle with the math, which makes ECC more secure for the long run.

Efficient Resource Usage

• Elliptic Curve Cryptography (ECC) requires a less computational power and bandwidth compared to other algorithms which lead to a faster cryptographic operations and reduced resource consumption.

Versatility and Flexibility

• Elliptic Curve Cryptography can be applied to various cryptographic operations like encryption, authentication, digital signatures, and key exchange protocols.

Lower Operational Costs

• The smaller key sizes and reduced computational overhead of ECC result in lower operational costs for implementing and managing cryptographic systems.

Standardization and Interoperability

• ECC has been standardized by organizations such as the National Institute of Standards and Technology (NIST), ensuring interoperability and compatibility across different systems and platforms.

Scalability and Future Proofing

• Elliptic Curve Cryptography is scalable, allowing for the adaptation of key sizes and security parameters to meet evolving security requirements and technological advancements.
• ECC resilience to quantum attacks and efficient resource usage make ECC a future-proof cryptographic solution for securing digital assets and communications.

Comparison between ECC vs RSA

The above table summarizes the key differences between Elliptic Curve Cryptography (ECC) and Rivest-Shamir-Adleman (RSA) in terms of key size, computational efficiency, security strength, resource consumption, and key management.