This is an automated email from the git hooks/post-receive script.

ppm-guest pushed a commit to annotated tag v0.21
in repository libmath-prime-util-perl.

commit 079e8b18faa6f18cb76a5a4704f161550d41b99c
Author: Dana Jacobsen <>
Date:   Thu Feb 21 01:46:24 2013 -0800

    Update documentation to reflect the change to Bytes::Random::Secure
 Changes                |  4 ++--
 lib/Math/Prime/ | 59 +++++++++++++++-----------------------------------
 2 files changed, 19 insertions(+), 44 deletions(-)

diff --git a/Changes b/Changes
index dc86582..1692028 100644
--- a/Changes
+++ b/Changes
@@ -2,6 +2,8 @@ Revision history for Perl extension Math::Prime::Util.
 0.21  ? February 2012
+    - Switch to using Bytes::Random::Secure for random primes.
     - Add circular and Panaitopol primes, speedup Pillai primes.
     - Spelling fixes in documentation.
@@ -12,8 +14,6 @@ Revision history for Perl extension Math::Prime::Util.
     - Speedup of divisor sum.  Also default to sigma if no sub given.
-    - Switch to using Bytes::Random::Secure.
 0.20  3 February 2012
     - Speedup for PP AKS, and turn off test on 32-bit machines.
diff --git a/lib/Math/Prime/ b/lib/Math/Prime/
index d73e781..608e994 100644
--- a/lib/Math/Prime/
+++ b/lib/Math/Prime/
@@ -2516,7 +2516,7 @@ bit size.
 Returns a psuedo-randomly selected prime that will be greater than or equal
 to the lower limit and less than or equal to the upper limit.  If no lower
 limit is given, 2 is implied.  Returns undef if no primes exist within the
-range.  The L<rand> function is called one or more times for selection.
 The goal is to return a uniform distribution of the primes in the range,
 meaning for each prime in the range, the chances are equally likely that it
@@ -2534,23 +2534,19 @@ uniformity but results in many fewer bits of randomness 
being consumed as
 well as being much faster.
 If an C<irand> function has been set via L</"prime_set_config">, it will be
-used.  The function should return a uniformly random 32-bit integer, which
-is how the irand functions exported by L<Math::Random::Secure>,
-L<Math::Random::MT>, L<Math::Random::ISAAC> and some other modules behave.
+used to construct any ranged random numbers needed.  The function should
+return a uniformly random 32-bit integer, which is how the irand functions
+exported by L<Math::Random::Secure>, L<Math::Random::MT>,
+L<Math::Random::ISAAC> and most other modules behave.
-If no C<irand> function was set, then we check if the sub C<main::rand>
-exists and use it if so.  It will be called with no arguments and should
-return a floating point value in the interval [0,1) with 32 bits of entropy.
-This allows the C<rand> function from most CPAN modules to be used.
-Lastly, if no C<irand> function was set and no sub <main::rand> exists, then
-the system rand will be used.  System rand functions are notoriously poor,
-and a later version of this module may implement something like TinyMT to
-cover the default case.
+If no C<irand> function was set, then L<Bytes::Random::Secure> is used with
+a non-blocking seed.  This will create good quality random numbers, so there
+should be little reason to change unless one is generating long-term keys,
+where using the blocking random source may be preferred.
 Examples of irand functions:
-  # Math::Random::Secure.  Uses ISAAC and strong seed methods.  Recommended.
+  # Math::Random::Secure.  Uses ISAAC and strong seed methods.
   use Math::Random::Secure;
   prime_set_config(irand => \&Math::Random::Secure::irand);
@@ -2566,24 +2562,6 @@ Examples of irand functions:
   use Math::Random::MT::Auto;
   prime_set_config(irand=>sub {Math::Random::MT::Auto::irand() & 0xFFFFFFFF});
-Examples of main::rand, where this is done in your script:
-  use Math::Random::Secure qw/rand/;
-  use Bytes::Random::Secure qw/random_bytes/;
-  sub rand { ($_[0]||1) * (unpack("L", random_bytes(4))/4294967296.0)}
-  use Math::Random::MT::Auto qw/rand/;
-  sub rand { ... do your own cool stuff here ... }
-For cryptographically secure primes, you need to use something better than the
-default for both seeding and random number generation.  I would recommend
-using L<Math::Random::Secure> and also installing L<Math::Random::ISAAC::XS>
-if possible.  It is reasonably fast and does everything needed by default.
-For more information, I recommend reading the documentation for
-L<Math::Random::Secure> and L<Bytes::Random::Secure>.
 =head2 random_ndigit_prime
@@ -2593,7 +2571,7 @@ Selects a random n-digit prime, where the input is an 
integer number of
 digits between 1 and the maximum native type (10 for 32-bit, 20 for 64-bit,
 10000 if bigint is active).  One of the primes within that range
 (e.g. 1000 - 9999 for 4-digits) will be uniformly selected using the
-L<rand> function as described above.
+C<irand> function as described above.
 If the number of digits is greater than or equal to the maximum native type,
 then the result will be returned as a BigInt.  However, if the '-nobigint'
@@ -2609,7 +2587,7 @@ Selects a random n-bit prime, where the input is an 
integer number of bits
 between 2 and the maximum representable bits (32, 64, or 100000 for native
 32-bit, native 64-bit, and bigint respectively).  A prime with the nth bit
 set will be uniformly selected, with randomness supplied via calls to the
-L<rand> function as described above.
+C<irand> function as described above.
 Since this uses the random_prime function, all uniformity properties of that
 function apply to this.  The n-bit range is partitioned into nearly equal
@@ -2661,9 +2639,6 @@ Ueli Maurer (1995).  This is the same algorithm used by 
 Similar to L</"random_nbit_prime">, the result will be a BigInt if the
 number of bits is greater than the native bit size.
-For cryptographic purposes you need to ensure you're using a good RNG that
-is well seeded.  See the notes for L</"random_prime">.
 The differences between this function and that in L<Crypt::Primes> include
@@ -2701,9 +2676,10 @@ Crypt::Primes has some useful options for cryptography.
 =item *
-Crypt::Primes is hardcoded to use L<Crypt::Random>, while M::P::U allows
-plugging in the random function.  This is more flexible but also prone to
-misuse.  You ought to use something like L<Math::Random::Secure>.
+Crypt::Primes is hardcoded to use L<Crypt::Random>, while M::P::U uses
+L<Bytes::Random::Secure>, and also allows plugging in a random function.
+This is more flexible, faster, has fewer dependencies, and uses a CSPRNG
+for security.
@@ -2788,8 +2764,7 @@ Allows setting of some parameters.  Currently the only 
parameters are:
   irand           Takes a code ref to an irand function returning a uniform
                   number between 0 and 2**32-1.  This will be used for all
-                  random number generation, and is the preferred way to use
-                  cryptographic RNGs.
+                  random number generation in the module.

Alioth's /usr/local/bin/git-commit-notice on 

Pkg-perl-cvs-commits mailing list

Reply via email to