#prime #numbers #generator #big #secure-random


A cryptographically secure prime number generator based on rust's own num-bigint and num-integer

17 releases (7 stable)

1.6.0 May 24, 2023
1.5.0 Oct 19, 2022
1.3.0 Sep 19, 2022
1.2.0 Sep 28, 2021
0.3.3 Feb 19, 2019

#598 in Cryptography

Download history 808/week @ 2023-12-15 363/week @ 2023-12-22 363/week @ 2023-12-29 1003/week @ 2024-01-05 946/week @ 2024-01-12 519/week @ 2024-01-19 592/week @ 2024-01-26 1150/week @ 2024-02-02 934/week @ 2024-02-09 767/week @ 2024-02-16 821/week @ 2024-02-23 507/week @ 2024-03-01 829/week @ 2024-03-08 866/week @ 2024-03-15 821/week @ 2024-03-22 456/week @ 2024-03-29

3,002 downloads per month
Used in 19 crates (8 directly)


713 lines

Glass Pumpkin

Build Status Build status [build status] Crate Docs Apache 2.0/MIT Licensed

A random number generator for generating large prime numbers, suitable for cryptography.


glass_pumpkin is a cryptographically-secure, random number generator, useful for generating large prime numbers. This library is inspired by pumpkin except its meant to be used with rust stable. It also lowers the 512-bit restriction to 128-bits so these can be generated and used for elliptic curve prime fields. It exposes the prime testing functions as well. This crate uses num-bigint instead of ramp. I have found num-bigint to be just as fast as ramp for generating primes. On average, generating primes takes less than 200ms and safe primes about 10 seconds on modern hardware.


Add the following to your Cargo.toml file:

glass_pumpkin = "1.0"


use glass_pumpkin::prime;

fn main() {
    let p = prime::new(1024).unwrap();
    let q = prime::new(1024).unwrap();

    let n = p * q;

    println!("{}", n);

You can also supply OsRng and generate primes from that.

use glass_pumpkin::prime;
use rand::rngs::OsRng;

fn main() {
    let mut rng = OsRng;
    let p = prime::from_rng(1024, &mut rng).unwrap();
    let q = prime::from_rng(1024, &mut rng).unwrap();

    let n = p * q;
    println!("{}", n);

Prime Generation

Primes are generated similarly to OpenSSL except it applies some recommendations from the Prime and Prejudice paper and uses the Baillie-PSW method:

  1. Generate a random odd number of a given bit-length.
  2. Divide the candidate by the first 2048 prime numbers. This helps to eliminate certain cases that pass Miller-Rabin but are not prime.
  3. Test the candidate with Fermat's Theorem.
  4. Runs log2(bitlength) + 5 Miller-Rabin tests with one of them using generator 2.
  5. Run lucas test.

Safe primes require (n-1)/2 also be prime.

Prime Checking

You can use this crate to check numbers for primality.

use glass_pumpkin::prime;
use glass_pumpkin::safe_prime;
use num_bigint::BigUint;

fn main() {

    if prime::check(&BigUint::new([5].to_vec())) {
        println!("is prime");

    if safe_prime::check(&BigUint::new([7].to_vec())) {
        println!("is safe prime");

Stronger prime checking that uses the Baillie-PSW method is an option by using the strong_check methods available in the prime and safe_prime modules. Primes generated by this crate will pass the Baillie-PSW test when using cryptographically secure random number generators. For now, prime::new() and safe_prime::new() will continue to use generation method as describe earlier.


~26K SLoC