Num-Primes: CSPRNG Large Composite, Prime, Safe Prime Generator

There is currently a major bug in is_prime() and is_composite() that makes some values return wrong

Num-Primes: CSPRNG Large Composite, Prime, Safe Prime Generator

This crate provides a beautifully simplistic API for generating large, cryptographically-random, unsigned integers in rust, including but not limited to composite, prime, and safe prime numbers.

It takes full advantage of the num crate on stable rust.

  • Read the About
  • Read the License
  • Read the Contribution

Notice

Please note there is a critical bug in this program that I cannot seem to fix where it marks some prime numbers as not prime. It is in the miller-rabin implementation and I cannot seem to fix it. If anyone is up to it, feel free to look through the issues tab for information about the bug and submit a PR if you find a fix.

Usage

Add this to your Cargo.toml:

Warning

There is currently a major bug in is_prime() and is_composite() that makes some values return wrong. For example, a prime can sometimes be marked as composite unless it was generated as they use the same tests to test for primality.

How To Use

There are three main structs that are included in this library

Structs Description
Generator Allows the random generation of composite numbers, prime numbers, and safe prime numbers.
Verification Allows the verification of composite, prime, safe prime, and very smooth numbers.
Factorization Allows the factorization of Composite and Prime Numbers into their largest Prime Factor.

Generator

Generate Composite Number

This function will generate a composite number of n-bits.

Generate Prime Number

This function will generate a prime number of n-bits.

Generate Safe Prime

This function will generate a safe prime number of n-bits. This function uses the same tests openssl uses to generate safe primes, which is (n-1)/2.

This function is quite time consuming and should be avoided for large sizes.

Generate Large Unsigned Integer

This function will generate a large unsigned integer of n-bits. This function is faster than generating a composite or prime number due to no checks being done.

Verification

WARNING: There is currently a bug that makes verification of certain prime numbers fail. Be careful when using this feature.

Verify Composite Number

This function will verify whether a BigUint type is a composite by returning a boolean value.

Verify Prime Number

This function will verify whether a BigUint type is a prime by returning a boolean value.

Verify Safe Prime Number

This function will verify whether a BigUint type is a safe prime by returning a boolean value.

[Experimental] Verify VSN (Smooth Numbers)

EXPERIMENTAL: Please Avoid Using This Function As Of Now

Read Wolfram Alpha - Smooth Numbers

Read OEIS - P-Smooth Numbers

Read Wikipedia - Examples of VSN and VSSR


This function will verify whether a number is a very smooth number. It accepts three parameters as follows:

  • m: &BigUint | prime
  • n: f64 | constant
  • c: u32 | constant

It follows the following equation:

  1. Return m's Greatest Prime Factor as p
    1. if p <= log(n)c then its p-smooth
    2. if p > log(n)c then its not p-smooth

Factorization

NOTICE: Factorization is still in the works.

Prime Factorization

Read GeeksforGeeks - Efficient program to print all prime factors of a given number


This function lets you factorize composite numbers and prime numbers to find their Greatest Prime Factor.

How Does It Work

The steps are listed below with n being the input number being factored:

A Primality Check is used first to determine whether the number is a prime or not.

  1. while n is even, divide by 2
  2. After Step 1, n must be odd.
    1. n_sqrt = Take the square root of n
  3. Start a loop from i = 3 to n_sqrt
    1. While i / n
      1. Divide n by i
    2. On Failure of i dividing by n,
      1. increment i by 2 and continue
  4. If n is a prime number and n > 2
    1. Return n

About

Prime Number Generation Design

The Prime Number Generation and parts of its code is based on Snips-AI's Medium Blog on Generating Prime Numbers.

A conservative attempt is made at deciding whether a number is prime or not. The number goes through the generation phase and 3 tests to determine if its prime:

Generation Phase

  1. A single parameter is passed to the generator function that indicates the number of bits the prime should be.

  2. The userspace CSPRNG is seeded by the operating system to generate the random numbers using the rand crate.

  3. An unsigned integer is generated until it passes the prime test.

  4. The number is sent to be processed by four tests

Primality Tests

The numbers go through multiple tests to determine whether they are composite or prime.

  1. A check is done to see if the number is even.
  2. An array of the first 2048 primes is used to check whether the number is divisble by any of the primes in the array.
  3. Fermat's Little Theorem is performed
  4. Miller-Rabin Primality Test, the gold standard recommended by the official RSA documentation and by NIST on generating primes, is performed with 16 iterations, the same used by Apple's cryptosystem.

If the number passes these tests, it is considered with high probability to be prime. Feel free to verify them yourselves on Wolfram Alpha by simply typing in the prime number.

Safe Primes

Safe Primes are generated simply by checking if (p-1)/2 is a prime with the tests listed above.

OpenSSL-Prime vs. Num-Primes

#404

OpenSSL LTS (1.1.1) has a doc page for prime generation, including how safe primes are generated.

OpenSSL should be prefered for serious cryptographic implementations due to the security of their code and their code having been audited.

Num-Primes may be useful in certain situations, like in embedded systems or where OpenSSLis overkill.


OpenSSL-prime:

  • Generates Safe Primes using (n-1)/2 but is much more efficient
  • Performs a default of 20 checks on prime numbers.

Num-Primes:

  • Generates Safe Primes using (n-1)/2 but takes much longer for unknown reasons
  • Performs a default of 16 checks on prime numbers through 4 different primality tests
  • Supports #[no_std] and stable rust
  • May be useful in situations where using OpenSSL would be overkill.

Differences Between num-primes and ramp-primes

ramp-primes is the original implementation of the prime number generator using the ramp library.

num-primes is the improved implementation using the num library and is available on stable release with no_std support.

num-primes (Stable)

Uses num, a pure-rust implementation for numeric types and traits.

  • num is stable and can work on the Default, Beta, and Nightly Branch

  • num is in Pure Rust

  • num implements more features

  • num has around ~6,000,000 downloads

  • num is more developed than ramp.

num-primes has:

  • Better API and Documentation
  • More Functionality
  • no_std support

ramp-primes (Unstable)

Uses ramp, a high-performance multiple-precision (aka "BigNum") library for working with numbers bigger than can normally be handled.

  • ramp only works on unstable rust (the nightly branch).
  • ramp is written in Rust and Inline Assembly (security concern)
  • ramp is generally faster
  • ramp is specifically focused on multiple-precision arithmetic
  • ramp has around ~17,000 downloads
  • ramp is not as developed as num

ramp-primes is:

  • The First Implementation
  • Generally Faster For Generation
  • Less Features
  • Only Works On Unstable Rust (Nightly Build)

License

Licensed under either of

  • Apache License, Version 2.0

  • MIT license

at your option.

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 dual licensed as above, without any additional terms or conditions.

Issues

Collection of the latest Issues

Superhepper

Superhepper

22

When I wrote a little program to check out how this crate works and I found something strange. Now I am not an expert in prime numbers so I might have done something wrong.

And the result I got was:

I expected both 17957 and 5 to be prime numbers. So I tried to generate a 8 bit prime number but then the program hang. I then tried to find the limit of the minimum number of bits for which a prime number could be generated and found that worked fine but made the program hang (probably stuck in an infinite loop some where).

Information - Updated May 14, 2022

Stars: 6
Forks: 3
Issues: 2

Rust library for Self Organising Maps (SOM)

Add rusticsom as a dependency in Cargo

Rust library for Self Organising Maps (SOM)

Rust library for parsing configuration files

The 'option' can be any string with no whitespace

Rust library for parsing configuration files

Rust library for the Pimoroni Four Letter pHAT

This library aims to port ht16k33 (or rather a fork, as of right now) so credit goes to ht16k33-diet

Rust library for the Pimoroni Four Letter pHAT

Rust library for emulating 32-bit RISC-V

This library can execute instructions against any memory and register file that implements

Rust library for emulating 32-bit RISC-V

Rust library for connecting to the IPFS HTTP API using Hyper/Actix

You can use actix-web as a backend instead of hyper

Rust library for connecting to the IPFS HTTP API using Hyper/Actix

Rust library to manipulate file system access control lists (ACL) on macOS, Linux, and FreeBSD

This module provides two high level functions, getfacl and setfacl

Rust library to manipulate file system access control lists (ACL) on macOS, Linux, and FreeBSD

Rust library translation (rust-src/rust-std/stdlib/rustlib translation)

This is the place to translate Having a documentation in your native language is essential if you don't speak English, and still enjoyable even if...

Rust library translation (rust-src/rust-std/stdlib/rustlib translation)

Rust library for using Infrared hardware decoders (For example a Vishay TSOP* decoder),

enabling remote control support for embedded project

Rust library for using Infrared hardware decoders (For example a Vishay TSOP* decoder),

Rust library for interaction with the OriginTrail Decentralized Knowledge Graph

open up an issue on this repository and let us know

Rust library for interaction with the OriginTrail Decentralized Knowledge Graph

Rust library for parsing COLLADA files

Notice: This library is built around files exported from Blender 2

Rust library for parsing COLLADA files

Rust library for low-level abstraction of MIPS32 processors

This project is licensed under the terms of the MIT license

Rust library for low-level abstraction of MIPS32 processors
Facebook Instagram Twitter GitHub Dribbble
Privacy