Cryptographical ly random numbers

[Tuvas]

Okay, I'm working on devoloping a simple, cryptographical ly secure
number, from a range of numbers (As one might do for finding large
numbers, to test if they are prime). My function looks like this:

def cran_rand(min,m ax):
if(min>max):
x=max
max=min
min=x
range=round(log (max-min)/log(256))
if range==0:
range=1
num=max+1
while(num>max):
num=min+s2num(u random(range))
return num

Any comments on this? I think it should hold up to a test, it seems to
work alright. Thanks!

[Emile van Sebille]

> def cran_rand(min,m ax):

You're shadowing built-ins here. Not a problem, but something I'd generally
avoid.

if(min>max):
x=max
max=min
min=x
If the args were a,b you could say:

maxarg,minarg = min(a,b),max(a, b)

range=round(log (max-min)/log(256))
more builtin shadowing...
if range==0:
range=1
or as alt_name_for_ra nge=... or 1
num=max+1
while(num>max):
num=min+s2num(u random(range))
I'll assume os.urandom is urandom. What's s2num?
return num

Any comments on this? I think it should hold up to a test, it seems to
work alright. Thanks!

If this does what you want, that's good. But someday when you look again
and see

while(num>max): num=min+s2num(u random(range))

you'll wonder...

Thankfully-python-uses-int-and-not-num-ly y'rs,

Emile van Sebille
em***@fenx.com

[Tuvas]

Good idea about the max and min values. Yes, urandom is os.urandom.
s2num('blah') will convert the phrase blah to ascii, and treat them as
if they were a big function.

Anyone else whose still interested, I found another small bug, but it
was in the modular (Again). It won't do much, but...

I did test out the RSA from end to end, found another small bug (I
imputed the text luke, and it decrypted to ekul), but it works good
now. Hopefully there's nothing left gaping, thanks for the help!

[Bryan Olson]

Tuvas wrote:

Okay, I'm working on devoloping a simple, cryptographical ly secure
number, from a range of numbers (As one might do for finding large
numbers, to test if they are prime). My function looks like this:

def cran_rand(min,m ax):
if(min>max):
x=max
max=min
min=x
range=round(log (max-min)/log(256))
if range==0:
range=1
num=max+1
while(num>max):
num=min+s2num(u random(range))
return num

Any comments on this? I think it should hold up to a test, it seems to
work alright.

Have to disagree. Try:

for _ in range(100):
print cran_rand(0, 500)

How many numbers greater than 255 do you get?
I have more comments, but that's the biggest issue.
--
--Bryan

[Tuvas]

Ahh, you are correct, that is a large bug... How about this one?

def s2num(text):
if(len(text)==1 ):
return ord(text)
else:
return ord(text[0])+256*s2num(tex t[1:])

def cran_rand(min,m ax):
range=int(log(a bs(max-min))/log(2))+1
num=max+1
if range%8==0:
crange=range/8
else:
crange=range/8+1
while(num>max):
num=min+s2num(u random(crange)) %(2**range)
return num

[Paul Rubin]

"Tuvas" <tu*****@gmail. com> writes:

def s2num(text):
if(len(text)==1 ):
return ord(text)
else:
return ord(text[0])+256*s2num(tex t[1:])
My favorite way to convert strings to numbers is with binascii:
from binascii import hexlify
def s2num(text):
return int(hexlify(tex t), 16)
def cran_rand(min,m ax):
range=int(log(a bs(max-min))/log(2))+1

This is kind of ugly and I wonder if it's possible for roundoff error
in the log function to make the answer off by 1, if max-min is very
close to a power of 2.

[Bryan Olson]

Paul Rubin wrote:

My favorite way to convert strings to numbers is with binascii:

from binascii import hexlify
def s2num(text):
return int(hexlify(tex t), 16)

Neat. I use the empty string as a binary representation of zero,
which you can accommodate with:

def s2num(text):
return int(hexlify(tex t) or '0', 16)
--
--Bryan

[Tuvas]

Wait, I now see that there is a native base 2 log in python, so I will
just do that rather than my adhoc way. The reason for adding one is to
make sure there isn't any problems if the log is, for instance, 2.2. It
will always round up. It's better to have to try twice to make sure the
number can have the max range than never use the top half, as the first
version did... That changes the function to:

def cran_rand(min,m ax):
range=int(log(a bs(max-min),2))+1
num=max+1
if range%8==0:
crange=range/8
else:
crange=range/8+1
while(num>max):
num=min+s2num(u random(crange)) %(2**range)
return num

As to the s2num(text), well, that looks really neat. Is there an easy
way to do the reverse of that? Thanks!

[Paul Rubin]

"Tuvas" <tu*****@gmail. com> writes:

Wait, I now see that there is a native base 2 log in python, so I will
just do that rather than my adhoc way. The reason for adding one is to
make sure there isn't any problems if the log is, for instance, 2.2. It
will always round up. It's better to have to try twice to make sure the
number can have the max range than never use the top half, as the first
version did... That changes the function to:
OK, if the log is one too high, you just have to do a few additional
retries.
As to the s2num(text), well, that looks really neat. Is there an easy
way to do the reverse of that? Thanks!

from binascii import unhexlify
def num2s(n):
s = '%X' % n
if len(s) % 2 == 1:
s = '0' + s # make sure length of hex string is even
return unhexlify(s)

[Bryan Olson]

Tuvas wrote:

Ahh, you are correct, that is a large bug... How about this one?

Much better. Do note the comments from Emile van Sebille and Paul
Rubin. There are some minor style and efficiency points, but it
looks reasonable.

Incidentally, as of Python 2.4, the standard library offers
random.SystemRa ndom, which will generate integers in any desired
range using os.urandom as the entropy source.
--
--Bryan