unknown_order

Crate for handling groups of unknown order.

I've seen this commonly across multiple projects where they need a multiprecision library and use one of three libraries: Gnu MP BigNum Library, OpenSSL's BigNum Library and Rust's BigInt Library, depending on the needs and requirements (licensing, performance, platform target, constant time).

The default is to use the pure rust option without any external C bindings. This version is also friendly to WASM.

To use OpenSSL's BigNum library, you must have libcrypto and libssl in your path. Put the following in your Cargo.toml.

unknown_order = { version = "0.1", default-features = false, features = ["openssl"] }

To use Gnu MP BigNum library, you must have libgmp in your path. Put the following in your Cargo.toml.

unknown_order = { version = "0.1", default-features = false, features = ["gmp"] }

This library wraps them all into a common API, so they can be used interchangeably.

Groups of unknown order require using a modulus that is the composite of two big prime numbers. This library is designed to facilitate these use cases such as RSA, Paillier, Hyperelliptic Curves, Accumulators, CL signatures.

The modulus is not known at compile time which excludes using certain traits like ff::PrimeField, so unfortunately, the caller needs to remember to use methods prefixed with mod to achieve the desired results.

This library can only have one implementation active at a time. Mixing between implementations isn't necessarily a problem as much as injecting lots of dependencies and mixing licenses which is not a good idea. This also forces the user to understand what tradeoffs they are making when they select a specific implementation. For example, some implementations may not be constant time versus others which is important when used for cryptographic purposes.

When using features=openssl or features=gmp, the constant time implementations are used if available.

Examples

use unknown_order::BigNumber;

fn main() {
    // Create a safe group of unknown order
    let p = BigNumber::safe_prime(1024);
    let q = BigNumber::safe_prime(1024);
    let n = p.clone() * q.clone();
    
    // Simulate RSA algorithm, DO NOT USE totally insecure
    
    // Public key
    let e = BigNumber::from(65537);
    
    // throw away when done
    let totient = (p.clone() - 1) * (q.clone() - 1);
    
    // Secret key
    let d = e.invert(&totient).unwrap();
    
    
}

License

Apache License, Version 2.0

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions.