Forge EC

Name: Forge EC
Author: Tanmay Patil

Modern Rust library for secure, high-performance elliptic curve cryptography

🦀 Zero-Unsafe Rust

⚡ SIMD Accelerated

🔒 Constant-Time

Cargo.toml

[dependencies]
forge-ec = "0.1.0"

Scroll to explore

⭐

GitHub Stars

🍴

Forks

📝

Commits

👥

Contributors

Advanced Features

Forge EC provides cutting-edge elliptic curve cryptography with uncompromising security and performance

Zero-Unsafe Rust

Built entirely in safe Rust with no unsafe blocks, ensuring memory safety and preventing common security vulnerabilities.

Memory Safe No Unsafe

SIMD Acceleration

Leverages modern CPU SIMD instructions for blazing-fast cryptographic operations with hardware-optimized performance.

AVX2 High Performance

Constant-Time Operations

All cryptographic operations execute in constant time, preventing timing attacks and ensuring side-channel resistance.

Timing Safe Side-Channel Resistant

Multiple Curves

Support for secp256k1, P-256, Ed25519, X25519, and other popular elliptic curves with unified API design.

secp256k1 Ed25519 P-256

RFC Compliance

Fully compliant with RFC 6979, RFC 8032, RFC 9380, and other cryptographic standards for interoperability.

RFC 6979 RFC 8032

Advanced Signatures

Support for ECDSA, EdDSA, Schnorr signatures, batch verification, and threshold cryptography schemes.

ECDSA EdDSA Schnorr

About Forge EC

Building the future of elliptic curve cryptography with security, performance, and developer experience at the forefront

Our Mission

Forge EC aims to democratize secure elliptic curve cryptography by providing a modern, safe, and high-performance Rust library. We believe that cryptographic security should be accessible to all developers without compromising on performance or safety.

🔒 Security First

⚡ Performance Optimized

🦀 Memory Safe

🌐 Standards Compliant

Core Team

Tanmay Patil

Lead Developer & Cryptographer

Passionate about cryptography and systems programming. Specializes in elliptic curve implementations and secure coding practices in Rust.

Contributors

Open source contributors who make Forge EC possible

Loading contributors...

View All Contributors

Development Roadmap

v0.1.0 - Foundation

Core elliptic curve operations, ECDSA signatures, and basic curve support

Completed

v0.2.0 - Advanced Features

EdDSA signatures, Schnorr signatures, and enhanced curve support

In Progress

v0.3.0 - Performance & Security

SIMD optimizations, formal verification, and security audit

Planned

v1.0.0 - Production Ready

Stable API, comprehensive documentation, and ecosystem integration

Future

Technical Philosophy

Security by Design

Every line of code is written with security as the primary concern. We use constant-time algorithms, secure random number generation, and follow cryptographic best practices.

Performance Without Compromise

We leverage Rust's zero-cost abstractions and modern CPU features like SIMD to deliver maximum performance without sacrificing security or safety.

Standards Compliance

Full compliance with cryptographic standards (RFC 6979, RFC 8032, RFC 9380) ensures interoperability and trust in our implementations.

Developer Experience

Clean APIs, comprehensive documentation, and helpful error messages make cryptography accessible to developers of all experience levels.

Quick Installation

Get started with Forge EC in seconds using Cargo

Add to Cargo.toml

Cargo.toml

[dependencies]
forge-ec = "0.1.0"

Import and Use

main.rs

use forge_ec::*;

fn main() {
    let private_key = PrivateKey::new();
    let message = b"Hello, Forge EC!";
    let signature = private_key.sign(message);

    assert!(verify(&signature, message, &private_key.public_key()));
}

Run and Test

Terminal

$ cargo run
   Compiling forge-ec v0.1.0
    Finished dev [unoptimized + debuginfo] target(s) in 2.34s
     Running `target/debug/main`
✅ Signature verified successfully!

Documentation Portal

Comprehensive guides, API reference, and best practices for Forge EC

Getting Started

Quick Start Guide

Get up and running with Forge EC in under 5 minutes

5 min read Beginner

Start Tutorial

Installation Guide

Multiple installation methods and dependency management

3 min read Beginner

View Guide

Configuration

Customize Forge EC for your specific use case

8 min read Intermediate

Configure

API Reference

Signatures Module

ECDSA, EdDSA, and Schnorr signature implementations

15 min read Intermediate

Browse API

Encoding Module

Point compression, serialization, and format conversion

12 min read Intermediate

Browse API

Hashing Module

Hash-to-curve, HMAC, and cryptographic hash functions

10 min read Advanced

Browse API

RNG Module

Secure random number generation and entropy sources

8 min read Intermediate

Browse API

Security & Best Practices

Security Guidelines

Essential security practices and common pitfalls to avoid

20 min read Advanced

Read Guide

Constant-Time Operations

Understanding and implementing timing-attack resistant code

15 min read Expert

Learn More

Vulnerability Disclosure

How to responsibly report security vulnerabilities

5 min read Beginner

Report Issue

Live Examples

Interactive code examples demonstrating Forge EC capabilities

Ready to run

Click "Run ECDSA Demo" to see the results

ECDSA Example

use forge_ec::ecdsa::*;
use forge_ec::curves::secp256k1::*;

fn main() -> Result<(), Box> {
    // Generate a new private key
    let private_key = PrivateKey::new();
    let public_key = private_key.public_key();

    // Message to sign
    let message = b"Hello, Forge EC ECDSA!";

    // Sign the message
    let signature = private_key.sign(message)?;

    // Verify the signature
    let is_valid = public_key.verify(message, &signature)?;

    println!("Signature valid: {}", is_valid);
    Ok(())
}

Ready to run

Click "Run EdDSA Demo" to see the results

EdDSA Example

use forge_ec::eddsa::*;
use forge_ec::curves::ed25519::*;

fn main() -> Result<(), Box> {
    // Generate Ed25519 keypair
    let private_key = PrivateKey::new();
    let public_key = private_key.public_key();

    // Message to sign
    let message = b"Hello, Forge EC EdDSA!";

    // Sign with Ed25519
    let signature = private_key.sign(message)?;

    // Verify signature
    let is_valid = public_key.verify(message, &signature)?;

    println!("Ed25519 signature valid: {}", is_valid);
    Ok(())
}

Ready to run

Click "Run ECDH Demo" to see the results

ECDH Example

use forge_ec::ecdh::*;
use forge_ec::curves::x25519::*;

fn main() -> Result<(), Box> {
    // Alice generates her keypair
    let alice_private = PrivateKey::new();
    let alice_public = alice_private.public_key();

    // Bob generates his keypair
    let bob_private = PrivateKey::new();
    let bob_public = bob_private.public_key();

    // Both parties compute the shared secret
    let alice_shared = alice_private.diffie_hellman(&bob_public)?;
    let bob_shared = bob_private.diffie_hellman(&alice_public)?;

    // Verify they computed the same secret
    assert_eq!(alice_shared, bob_shared);
    println!("Shared secret established!");
    Ok(())
}

Ready to run

Click "Run Schnorr Demo" to see the results

Schnorr Example

use forge_ec::schnorr::*;
use forge_ec::curves::secp256k1::*;

fn main() -> Result<(), Box> {
    // Generate Schnorr keypair
    let private_key = PrivateKey::new();
    let public_key = private_key.public_key();

    // Message to sign
    let message = b"Hello, Forge EC Schnorr!";

    // Create Schnorr signature
    let signature = private_key.sign_schnorr(message)?;

    // Verify Schnorr signature
    let is_valid = public_key.verify_schnorr(message, &signature)?;

    println!("Schnorr signature valid: {}", is_valid);
    Ok(())
}